<template>
  <div class="basic-info">
    <el-form :model="form" ref="form" label-width="88px" size="mini" :rules="addRules" :disabled="formDisabled || mode === 'view'">
      <el-row :gutter="24">

        <!-- 药品名称输入框部分修改 -->
          <el-col :xs="6" :sm="6" :md="8" :lg="8" :xl="8">
            <el-form-item label="药品名称：" prop="name">
              <el-input 
                v-model="form.name" 
                @blur="updateForm"
                @input="handleNameInput">
              </el-input>
            </el-form-item>
          </el-col>
        <!-- 拼音简码部分保持不变 -->
          <el-col :xs="6" :sm="6" :md="8" :lg="8" :xl="8">
            <el-form-item label="拼音简码：" prop="pyCode">
              <el-input 
                v-model="form.pyCode" 
                @blur="updateForm"
                disabled>
              </el-input>
            </el-form-item>
          </el-col>
        
		<!-- 药品别名部分保持不变 -->
         <el-col :xs="12" :sm="12" :md="8" :lg="8" :xl="8">
           <el-form-item label="药品别名：" prop="alis">
             <el-input 
               v-model="form.alis" 
               @blur="updateForm"
               @input="handleAliasInput">
             </el-input>
           </el-form-item>
         </el-col>
		  
		<el-col :xs="12" :sm="12" :md="8" :lg="8" :xl="8">
			<el-form-item label="别名简码：" prop="alisPyCode">
			  <el-input 
				v-model="form.alisPyCode" 
				@blur="updateForm"
				>
			  </el-input>
			</el-form-item>
		</el-col>
		
		<el-col :xs="12" :sm="12" :md="8" :lg="8" :xl="8">
			<el-form-item label="有效状态：" prop="state">
			  <el-select v-model="form.state" @change="updateForm">
					<el-option v-for="item in statusOptions" :key="item.id" :label="item.label" :value="item.id">
						<span>{{ item.label }}</span>
					</el-option>
			  </el-select>
			</el-form-item>
		</el-col>
		
        <el-col :xs="12" :sm="12" :md="8" :lg="8" :xl="8">
          <el-form-item label="规格描述：" prop="drugSpec">
            <el-input v-model="form.drugSpec" @blur="updateForm"></el-input>
          </el-form-item>
        </el-col>
 
		
        <el-col :xs="12" :sm="12" :md="6" :lg="6" :xl="8">
          <el-form-item label="包装单位：" prop="pacUnt">
            <el-select 
              v-model="form.pacUnt" 
              filterable 
              @change="handleUnitChange">
              <el-option v-for="item in unitDoseOptions" :key="item.id" :label="item.label" :value="item.id">
                <span>{{ item.label }}</span>
              </el-option>
            </el-select>
          </el-form-item>
        </el-col>
        <el-col :span="12" :sm="12" :md="5" :lg="5" :xl="8">
          <el-form-item label="包装数量：" prop="pacCnt">
            <el-input 
              v-model.number="form.pacCnt" 
              @blur="updateForm"
              :disabled="formDisabled || mode === 'view' || isSameUnit"
              min="1">
            </el-input>
          </el-form-item>
        </el-col>
		
		<el-col :xs="12" :sm="12" :md="5" :lg="5" :xl="8">
		  <el-form-item label="最小单位：" prop="minUnt">
		    <el-select 
		      v-model="form.minUnt" 
		      filterable 
		      @change="handleUnitChange">
		      <el-option v-for="item in unitDoseOptions" :key="item.id" :label="item.label" :value="item.id">
		        <span>{{ item.label }}</span>
		      </el-option>
		    </el-select>
		  </el-form-item>
		</el-col>
		
        <el-col :xs="12" :sm="12" :md="8" :lg="8" :xl="8">
          <el-form-item label="剂量/单位：" prop="dosCnt">
			  <div class="box" style="display: flex;justify-content: space-around;">
				<el-input v-model="form.dosCnt"  prop="dosCnt" @blur="updateForm"></el-input>
				<!-- 单位 -->
				<el-select v-model="form.dosUnt" filterable  prop="dosUnt" @change="updateForm" style="margin-left: 4px;">
				  <el-option v-for="item in getDosaUntOptions" :key="item.id" :label="item.label" :value="item.id">
					<span>{{ item.label }}</span>
				  </el-option>
				</el-select>
			  </div>
          </el-form-item>
        </el-col>
        
		<!-- 确保成本单价输入框也触发计算 -->
        <el-col :xs="12" :sm="12" :md="6" :lg="6" :xl="8">
          <el-form-item label="成本单价：" prop="costPric">
            <el-input 
              v-model="form.costPric" 
              @input="handleCostPriceChange"
              @blur="updateForm">
            </el-input>
          </el-form-item>
        </el-col>
		
        <el-col :xs="12" :sm="12" :md="6" :lg="6" :xl="8">
          <el-form-item label="零售单价：" prop="salePric">
            <el-input v-model="form.salePric" disabled @blur="updateForm"></el-input>
          </el-form-item>
        </el-col>
        
        <el-col :xs="12" :sm="12" :md="6" :lg="6" :xl="8">
          <el-form-item label="零售单位：" prop="saleUnt">
            <el-select v-model="form.saleUnt" filterable @change="updateForm">
				<el-option v-for="item in saleWaysOptions" :key="item.id" :label="item.label" :value="item.id">
					<span>{{ item.label }}</span>
				</el-option>
<!--              <el-option label="最小单位" value="1"></el-option>
              <el-option label="包装单位" value="2"></el-option> -->
            </el-select>
          </el-form-item>
        </el-col>
		<el-col :xs="12" :sm="12" :md="6" :lg="6" :xl="8">
		  <el-form-item label="贵重类型：" prop="expensiveType">
		    <el-select v-model="form.expensiveType" filterable @change="updateForm">
		      <el-option v-for="item in expensiveTypeOptions" :key="item.id" :label="item.label" :value="item.id">
		      	<span>{{ item.label }}</span>
		      </el-option>
		    </el-select>
		  </el-form-item>
		</el-col>
		
		<el-col :xs="12" :sm="12" :md="6" :lg="6" :xl="8">
		  <el-form-item label="加成方式：" prop="markUpId">
		    <el-select v-model="form.markUpId" @change="handleMarkUpChange">
				<el-option v-for="item in markUpOption" :key="item.id" :label="item.label" :value="item.id">
					<span>{{ item.label }}</span>
				</el-option>
		    </el-select>
		  </el-form-item>
		</el-col>
		<el-col :xs="12" :sm="12" :md="6" :lg="6" :xl="8">
		  <el-form-item label="固定加成：" prop="markUpFixed">
		    <el-select v-model="form.markUpFixed" @change="updateForm">
		      <el-option v-for="item in YNoptions" :key="item.id" :label="item.label" :value="item.id">
		      	<span>{{ item.label }}</span>
		      </el-option>
		    </el-select>
		  </el-form-item>
		</el-col>
		<!-- 加成比例输入框 --> <!-- 新增专门处理手工比例加成的事件 -->
		<el-col :xs="12" :sm="12" :md="6" :lg="6" :xl="8">
		  <el-form-item label="加成比例：" prop="markUpRate">
		    <el-input 
		      v-model="form.markUpRate" 
		      :disabled="form.markUpId !== 3"
		      @input="handleManualMarkUpRateChange" 
		      @blur="updateForm">
		      <template v-if="form.markUpId == 3" #append>%</template>
		    </el-input>
		  </el-form-item>
		</el-col>
		  <!-- 新增输入事件 -->
		<el-col :xs="12" :sm="12" :md="6" :lg="6" :xl="8">
		  <el-form-item label="加成金额：" prop="markUpPric">
		    <el-input 
		      v-model="form.markUpPric" 
		      :disabled="form.markUpId !== 2"
		      @input="handleFixedMarkupChange"
		      @blur="updateForm">
		    </el-input>
		  </el-form-item>
		</el-col>
		
      </el-row>
    </el-form>
  </div>
</template>

<script>
	// 在顶部引入pinyin-pro
	import { pinyin } from 'pinyin-pro';
	// axios
	import { getDrugUnt,selectDocVtByType,getMedicationFrequency,getDosaUnt,
		selectOneCateGory,selectTwoCateGory,selectThreeCateGory,getMedicationWay,getMedcas,
	} from "@/api/MedicenCata.js";
	// axios
	import { docMarkById } from "@/api/MedicenCata.js";
export default {
  props: {
    form: {
      type: Object,
      required: true
    },
    formDisabled: {
      type: Boolean,
      default: false
    },
    mode: {
      type: String,
      default: 'add' // 'add', 'edit', 'view'
    },
    disablePackingQuantity: {
      type: Boolean,
      default: false
    }
  },
  computed: {
    isSameUnit() {
      return this.form.pacUnt && this.form.minUnt && this.form.pacUnt === this.form.minUnt;
    }
  },
  data(){
  	return{
		costPriceTimer: null,
		unitDoseOptions:[], // 包装单位
		getDosaUntOptions:[], // 剂量单位
		getMinUntOptions:[], // 最小单位
		methodTypeOptions:[], // 默认制法
		// 新增选项数据
		clinicId:'',  // 当前诊所id
		drugCategoryOption: [], // 药理类别选项
		drugCategoryChildOption: [], // 药理类别II选项
		threeLevelDrugCategoryOption: [], // 药理类别III选项
		usedFrquIdOptions:[], // 默认给药方式
		expensiveTypeOptions:[{id:1,label:'普价'},{id:2,label:'贵重'},{id:3,label:'昂贵'},{id:4,label:'免费'}], // 贵重类型
		roundUntoptions:[{id:1,label:'单次取整'},{ id:2,label:'总量取整'},{id:3,label:'处方取整'}], //取整方式
		poisonousTypeOption:[], // 毒麻
		YNoptions:[{id:0,label:'否',value:'否'},{id:1,label:'是',value:'是'}],
		statusOptions:[{id:0,label:'禁用'},{id:1,label:'可用'}],  
		saleWaysOptions:[{id:1,label:'最小单位'},{id:2,label:'包装单位'}],
		markUpOption:[ { id:1,label:'比例加成'},{ id:2,label:'固定加成'},{ id:3,label:'手工比例加成'},{ id:4,label:'不加成'}],
		medcWayIdOptions:[], // 用药频率
		medicalRecordFeeOption:[], //病案费别
		// 其他数据保持不变...
		addRules: {
			// 其他规则保持不变...
			markUpId: [{ required: true, message: " ", trigger: "blur" }],
			pacUnt: [{ required: true, message: " ", trigger: "blur" }],
			pacCnt: [
			    { required: true, message: '请输入包装数量', trigger: 'blur' },
			    { 
			      validator: (rule, value, callback) => {
			        if (this.isSameUnit && value !== 1) {
			          callback(new Error('当包装单位和最小单位相同时，包装数量必须为1'));
			        } else if (!/^[1-9]\d*$/.test(value)) {
			          callback(new Error('请输入大于0的正整数'));
			        } else {
			          callback();
			        }
			      }, 
			      trigger: 'blur' 
			    }
			  ],
			unitDose: [{ required: true, message: " ", trigger: "blur" }],
			minDose: [{ required: true, message: " ", trigger: "blur" }],
			
			roundUnt: [{ required: true, message: " ", trigger: "change" }],
			mrsId: [{ required: true, message: " ", trigger: "change" }],
			markUpRate: [ 
			  { 
				required: false, // 初始为非必填
				pattern: /^[1-9]\d*(\.\d+)?$/, 
				message: '请输入大于0的数字', 
				trigger: 'blur' 
			  }
			],
			saleUnt: [{ required: true, message: " ", trigger: "change" }],
			minUnt: [{ required: true, message: " ", trigger: "change" }],
			// markUpPric: [ 
			//   { 
			// 	required: false,
			// 	pattern: /^[1-9]\d*(\.\d+)?$/, 
			// 	message: '请输入大于0的数字', 
			// 	trigger: 'blur' 
			//   }
			// ],
			costPric: [
			    { 
			      required: true, 
			      message: '成本单价不能为空', 
			      trigger: 'blur' 
			    },
			    { 
			      validator: (rule, value, callback) => {
			        // 允许0.0001这样的小数
			        if (value === '' || value === null || value === undefined) {
			          callback(new Error('成本单价不能为空'));
			          return;
			        }
			        
			        const numValue = parseFloat(value);
			        if (isNaN(numValue)) {
			          callback(new Error('请输入有效的数字'));
			          return;
			        }
			        
			        if (numValue <= 0) {
			          callback(new Error('请输入大于0的数字'));
			          return;
			        }
			        
			        // 检查小数位数
			        const decimalPart = value.toString().split('.')[1];
			        if (decimalPart && decimalPart.length > 4) {
			          callback(new Error('最多支持4位小数'));
			          return;
			        }
			        
			        // 检查总长度
			        if (value.toString().length > 10) {
			          callback(new Error('长度不能超过10位'));
			          return;
			        }
			        
			        callback();
			      },
			      trigger: 'blur'
			    }
			  ],
			  // 零售单价规则（如果需要）
			  salePric: [
			    { 
			      validator: (rule, value, callback) => {
			        if (value === '' || value === null || value === undefined) {
			          callback();
			          return;
			        }
			        
			        const numValue = parseFloat(value);
			        if (isNaN(numValue)) {
			          callback(new Error('请输入有效的数字'));
			          return;
			        }
			        
			        if (numValue <= 0) {
			          callback(new Error('请输入大于0的数字'));
			          return;
			        }
			        
			        // 检查小数位数
			        const decimalPart = value.toString().split('.')[1];
			        if (decimalPart && decimalPart.length > 4) {
			          callback(new Error('最多支持4位小数'));
			          return;
			        }
			        
			        callback();
			      },
			      trigger: 'blur'
			    }
			  ],
			  markUpPric: [
				{ 
				  required: false, // 初始为非必填
				  validator: (rule, value, callback) => {
					// 仅在固定加成模式下必填
					if (this.form.markUpId === 2 && !value) {
					  callback(new Error('请输入固定加成金额'));
					} else if (value && !/^[1-9]\d*(\.\d{1,2})?$/.test(value)) {
					  callback(new Error('请输入大于0的数字，最多两位小数'));
					} else {
					  callback();
					}
				  },
				  trigger: 'blur'
				}
			  ],
			matchedMarkUpItems: [], // 存储匹配的加成率规则
		},
		watch: {
		isSameUnit(newVal) {
			if (newVal) {
			  this.form.pacCnt = 1;
			  this.$message.info('包装单位和最小单位相同，包装数量已自动设置为1');
			  this.updateForm();
			}
		  },
		// 深度监听form.name的变化
		'form.name': {
			  immediate: true, // 立即执行一次
			  handler(newVal) {
				if (newVal) {
				  this.form.pyCode = this.generatePinyinCode(newVal);
				} else {
				  this.form.pyCode = '';
				}
			  }
			},
		'form.pacUnt'(newVal, oldVal) {
		  this.checkAndSetPacCnt();
		},
		'form.minUnt'(newVal, oldVal) {
		  this.checkAndSetPacCnt();
		}
		},
	}
  },
  mounted() {
	  this.$nextTick(() => {
	    this.pacUnt(); // 包装单位
	    this.getDocVtByType(); // 毒麻
	    this.getDosaUnts(); // 最小单位
	    this.getMedicationFrequency(); // 给药方式
	    this.getDosaUnts(); // 剂量/单位
	    this.getMedicationWay(); // 用药频率 
	    this.getMedcas(); // 病案费别
	    this.selectOneCateGory(); //药理类别
	  });
  	// 从本地存储获取userInfo
  	  const userInfo = JSON.parse(localStorage.getItem('userInfo'));
	  this.clinicId = userInfo.clinicId
  },
  // 在组件销毁时清除定时器
  beforeDestroy() {
    if (this.costPriceTimer) {
      clearTimeout(this.costPriceTimer);
    }
  },
	methods: {
    updateForm() {
		this.$emit('update', this.form);
	},
	// // 包装单位聚焦
	// handlefoucsPac(){
	// 	this.pacUnt(); // 包装单位
	// },
	// // 毒麻聚焦
	// handlefoucsDm(){
	// 	this.getDocVtByType(); // 毒麻
	// },
	// // 给药方式
	// handlefoucsGy(){
	// 	this.getMedicationFrequency(); // 给药方式
	// },
	// // 剂量/单位
	// handlefoucsJl(){
	// 	this.getDosaUnts(); // 剂量/单位
	// },
	// handlefoucsYY(){
	// 	this.getMedicationWay(); // 用药频率 
	// },
	// handlefoucsBBFB(){
	// 	this.getMedcas(); // 病案费别
	// },
	// 处理药品名称输入
	    handleNameInput(value) {
	      // 自动生成拼音简码
	      this.form.pyCode = this.generatePinyinCode(value);
	      this.updateForm();
	    },
	    
	    // 处理药品别名输入
	    handleAliasInput(value) {
	      // 自动生成别名简码
	      this.form.alisPyCode = this.generatePinyinCode(value);
	      this.updateForm();
	    },
	    
	// 优化后的拼音简码生成方法
	generatePinyinCode(str) {
	  if (!str || typeof str !== 'string') return '';
	  
	  try {
		// 1. 提取所有汉字
		const chineseChars = str.match(/[\u4e00-\u9fa5]/g) || [];
		if (chineseChars.length === 0) return '';
		
		// 2. 对每个汉字获取拼音首字母
		const initials = chineseChars.map(char => {
		  const pinyinResult = pinyin(char, {
			toneType: 'none',
			pattern: 'first',
			type: 'array'
		  })[0] || '';
		  return pinyinResult.charAt(0).toUpperCase();
		});
		
		// 3. 组合成简码（如"中国" → "ZG"）
		return initials.join('');
	  } catch (error) {
		console.error('拼音转换失败:', error);
		return '';
	  }
	},
	
	// 处理名称变化（实时响应）
	handleNameChange(value) {
	  this.form.pyCode = this.generatePinyinCode(value);
	},
		
	// 验证数字有效性
	  isValidNumber(value) {
	    return !isNaN(parseFloat(value)) && isFinite(value);
	  },
	
	// 修改后的handleUnitChange方法
	handleUnitChange() {
	  // 检查包装单位和最小单位是否相同
	  if (this.form.pacUnt && this.form.minUnt && 
	      this.form.pacUnt === this.form.minUnt) {
	    this.form.pacCnt = 1;
	    this.$message.info('当包装单位和最小单位相同时，包装数量只能为1');
	  }
	  this.updateForm();
	},
	checkAndSetPacCnt() {
	    if (this.isSameUnit) {
	      this.$nextTick(() => {
	        this.form.pacCnt = 1;
	        this.$message.info('包装单位和最小单位相同，包装数量已自动设置为1');
	        this.updateForm();
	      });
	    }
	  },
	// 计算手工比例加成
	  calculateManualMarkUp() {
	    if (this.form.markUpId !== 3 || !this.form.costPric || !this.form.markUpRate) {
	      return;
	    }
	    
	    const cost = parseFloat(this.form.costPric);
	    const rate = parseFloat(this.form.markUpRate) / 100;
	    
	    if (this.isValidNumber(cost) && this.isValidNumber(rate)) {
	      this.form.salePric = (cost * (1+rate)).toFixed(2);
	      this.updateForm();
	    }
	  },
	  
	// 处理固定加成金额变化
	// 修改handleFixedMarkupChange方法，保留4位小数
	handleFixedMarkupChange(value) {
	  if (this.form.markUpId === 2 && this.form.costPric) {
	    // 计算零售单价 = 成本单价 + 加成金额
	    const cost = parseFloat(this.form.costPric);
	    const markup = parseFloat(value) || 0;
	    
	    if (!isNaN(cost)) {
	      this.form.salePric = (cost + markup).toFixed(4);
	      this.updateForm();
	    }
	  }
	},
		
	// 处理成本单价变化（也需要考虑固定加成情况）
	// 修改handleCostPriceChange方法，确保输入时处理4位小数
	handleCostPriceChange(value) {
	  // 更新成本单价
	  this.form.costPric = value;
	  
	  // 限制小数位数为4位
	  if (value && value.includes('.')) {
	    const parts = value.split('.');
	    if (parts[1].length > 4) {
	      this.form.costPric = parts[0] + '.' + parts[1].substring(0, 4);
	    }
	  }
	  
	  // 其他逻辑保持不变...
	  if (this.form.markUpId === 1) {
	    if (value && !isNaN(parseFloat(value))) {
	      if (this.costPriceTimer) {
	        clearTimeout(this.costPriceTimer);
	      }
	      this.costPriceTimer = setTimeout(() => {
	        this.calculateMarkUpRate();
	      }, 500);
	    } else {
	      this.form.markUpRate = '';
	      this.form.salePric = '';
	    }
	  }
	  
	  // 其他加成方式的处理保持不变
	  if (this.form.markUpId === 2 && this.form.markUpPric) {
	    this.handleFixedMarkupChange(this.form.markUpPric);
	  } else if (this.form.markUpId === 3 && this.form.markUpRate) {
	    this.calculateManualMarkUp();
	  } else if (this.form.markUpId === 4) {
	    this.form.salePric = value;
	  }
	  
	  this.updateForm();
	},
	
	// 新增防抖方法
	debounceCalculateMarkUpRate: _.debounce(function() {
	  this.calculateMarkUpRate();
	}, 500),

	// 新增方法：处理药理类别变化
	handlePhamType1Change(value) {
	  // 清空下级选择
	  this.form.phamType2 = '';
	  this.form.phamType3 = '';
	  
	  // 根据选择的值加载药理类别II选项
	  this.loadDrugCategoryChildOptions(value);
	  
	  this.updateForm();
	},
	
	// 专门处理手工比例加成(markUpId=3)的输入变化
	handleManualMarkUpRateChange(value) {
	  if (this.form.markUpId === 3 && this.form.costPric) {
	    // 手工比例加成需要将markUpRate除以100
	    const cost = parseFloat(this.form.costPric);
	    const rate = parseFloat(value) / 100;
	    
	    // 确保计算结果是数字且有效
	    if (!isNaN(cost) && !isNaN(rate)) {
	      this.form.salePric = (cost * (1 + rate)).toFixed(4);
	      this.updateForm();
	    }
	  }
	},
	// 新增方法：处理药理类别II变化
	handlePhamType2Change(value) {
	  // 清空下级选择
	  this.form.phamType3 = '';
	  
	  // 根据选择的值加载药理类别III选项
	  this.loadThreeLevelDrugCategoryOptions(value);
	  
	  this.updateForm();
	},
	
	// 加载药理类别II选项loadDrugCategoryChildOptions
	async loadDrugCategoryChildOptions(parentId) {
	    try {
	        // 获取选中的药理类别对象
	        const selectedCategory = this.drugCategoryOption.find(item => item.id === parentId);
	        
	        if (selectedCategory) {
	          // 使用选中的药理类别的idcode作为参数
	          const res = await selectTwoCateGory({idcode: selectedCategory.idcode});
	          if (res.code === 200) {
	            this.drugCategoryChildOption = res.data;
	          } else {
	            this.drugCategoryChildOption = [];
	          }
	        } else {
	          this.drugCategoryChildOption = [];
	        }
	    } catch (error) {
	        console.error('加载药理类别II选项失败:', error);
	        this.drugCategoryChildOption = [];
	  }
	},
	
	// 加载药理类别III选项
	async loadThreeLevelDrugCategoryOptions(parentId) {
	  try {
		// 获取选中的药理类别II对象
		const selectedCategory = this.drugCategoryChildOption.find(item => item.id === parentId);
		
		if (selectedCategory) {
		  // 使用选中的药理类别II的idcode作为参数
		  const res = await selectThreeCateGory({idcode: selectedCategory.idcode});
		  if (res.code === 200) {
			this.threeLevelDrugCategoryOption = res.data;
		  } else {
			this.threeLevelDrugCategoryOption = [];
		  }
		} else {
		  this.threeLevelDrugCategoryOption = [];
		}
	  } catch (error) {
		console.error('加载药理类别III选项失败:', error);
		this.threeLevelDrugCategoryOption = [];
	  }
	},
	// 处理别名简码输入事件
	handleAliasPyCodeInput(value) {
	  console.log('别名简码输入:', value);
	  this.updateForm(); // 触发更新
	},

	// 处理加成方式变化
	// 修改后的handleMarkUpChange方法
	async handleMarkUpChange(value) {
	  // 根据不同的加成方式设置不同的逻辑
	  if (value === 1) { // 比例加成
	    this.form.markUpPric = ''; // 清空加成金额
	    this.form.markUpFixed = 0; // 设置为非固定加成
	    
	    // 检查是否有成本单价
	    if (!this.form.costPric || isNaN(parseFloat(this.form.costPric))) {
	      this.$message.warning('请先输入有效的成本单价');
	      this.form.markUpRate = '';
	      this.form.salePric = '';
	      return;
	    }
	    
	    const costPrice = parseFloat(this.form.costPric);
	    
	    // 调用接口获取加成率
	    try {
	      const res = await docMarkById({ 
	        clinicId: this.clinicId,
	        drugType: 2 // 2表示中药加成率
	      });
	      
	      if (res.code === 200 && res.data && res.data.length > 0) {
	        // 过滤出中药加成率且markUpType为1的规则
	        const validRules = res.data.filter(item => 
	          item.drugType === 2 && item.markUpType === 1
	        );
	        
	        if (validRules.length > 0) {
	          // 筛选出成本单价在区间内的规则
	          const matchedItems = validRules.filter(item => {
	            const min = Math.min(item.pricLmtLow, item.pricLmtTop);
	            const max = Math.max(item.pricLmtLow, item.pricLmtTop);
	            return costPrice >= min && costPrice <= max;
	          });
	          
	          if (matchedItems.length > 0) {
	            // 取id最大的规则
	            const latestRule = matchedItems.reduce((prev, current) => 
	              (prev.id > current.id) ? prev : current
	            );
	            
	            this.form.markUpRate = latestRule.markUpRate;
	            this.calculateSalePrice();
	          } else {
	            this.$message.error('未找到匹配当前成本单价的加成率规则');
	            this.form.markUpRate = '';
	            this.form.salePric = '';
	          }
	        } else {
	          this.$message.error('当前未设置中药比例加成规则，请先前往设置！');
	          this.form.markUpRate = '';
	          this.form.salePric = '';
	        }
	      } else {
	        this.$message.error('当前未设置中药相关加成率，请先前往设置！');
	        this.form.markUpRate = '';
	        this.form.salePric = '';
	      }
	    } catch (error) {
	      console.error('获取加成率失败:', error);
	      this.$message.error('获取加成率失败');
	      this.form.markUpRate = '';
	      this.form.salePric = '';
	    }
	  } 
	  else if (value === 2) { // 固定加成
	    this.form.markUpRate = ''; // 清空加成比例
	    this.form.markUpFixed = 1; // 设置为固定加成
	    this.form.markUpPric = ''; // 清空加成金额
	    
	    // 如果已有成本单价，立即计算
	    if (this.form.costPric) {
	      this.calculateSalePrice();
	    }
	  }
	  else if (value === 3) { // 手工比例加成
	    this.form.markUpPric = ''; // 清空加成金额
	    this.form.markUpFixed = 0; // 设置为非固定加成
	    
	    // 如果已有成本单价和加成率，立即计算
	    if (this.form.costPric && this.form.markUpRate) {
	      this.calculateSalePrice();
	    }
	  }
	  else if (value === 4) { // 不加成
	    this.form.markUpPric = ''; // 清空加成金额
	    this.form.markUpRate = ''; // 清空加成比例
	    this.form.markUpFixed = 0; // 设置为非固定加成
	    
	    // 零售价=成本价
	    if (this.form.costPric) {
	      this.form.salePric = this.form.costPric;
	    } else {
	      this.form.salePric = '';
	    }
	  }
	  
	  this.updateForm();
	},
	
	// 修改计算销售价格的方法，保留4位小数
	calculateSalePrice() {
	  if (!this.form.costPric) return;
	  
	  const cost = parseFloat(this.form.costPric);
	  
	  if (this.form.markUpId === 1 && this.form.markUpRate) {
	    // 比例加成: 成本 * 加成率
	    const rate = this.form.markUpRate;
	    this.form.salePric = (cost * rate).toFixed(4);
	  } 
	  else if (this.form.markUpId === 2 && this.form.markUpPric) {
	    // 固定加成: 成本 + 固定金额
	    const markup = parseFloat(this.form.markUpPric);
	    this.form.salePric = (cost + markup).toFixed(4);
	  }
	  else if (this.form.markUpId === 3 && this.form.markUpRate) {
	    // 手工比例加成: 成本 * (1 + 手工比例/100)
	    const rate = parseFloat(this.form.markUpRate) / 100;
	    this.form.salePric = (cost * (1 + rate)).toFixed(4);
	  }
	  else if (this.form.markUpId === 4) {
	    // 不加成: 零售价=成本价
	    this.form.salePric = cost.toFixed(4);
	  }
	  
	  this.updateForm();
	},
	
	// 可以移除原来的calculateMarkUpRate方法
	// 可以移除原来的handleCostPricBlur方法中的加成率计算逻辑
	// 计算加成率和销售单价
	// 修改后的calculateMarkUpRate方法
	async calculateMarkUpRate() {
	  try {
	    // 确保是比例加成模式
	    if (this.form.markUpId !== 1) return false;
	    
	    // 确保成本单价有效
	    if (!this.form.costPric || isNaN(parseFloat(this.form.costPric))) {
	      this.$message.warning('请输入有效的成本单价');
	      return false;
	    }
	
	    const costPrice = parseFloat(this.form.costPric);
	    
	    // 调用接口获取中药加成率规则 (drugType=2 表示中药)
	    const res = await docMarkById({ 
	      clinicId: this.clinicId,
	      drugType: 2 // 2表示中药加成率
	    });
	    
	    if (res.code === 200) {
	      if (res.data && res.data.length > 0) {
	        // 1. 首先过滤出匹配的区间 - 确保成本单价在pricLmtLow和pricLmtTop之间
	        const matchedItems = res.data.filter(item => {
	          const min = Math.min(item.pricLmtLow, item.pricLmtTop);
	          const max = Math.max(item.pricLmtLow, item.pricLmtTop);
	          return costPrice >= min && costPrice <= max;
	        });
	        
	        if (matchedItems.length > 0) {
	          // 2. 如果有多个匹配项，找出pricLmtLow最小的规则
	          const selectedRule = matchedItems.reduce((prev, current) => 
	            (prev.pricLmtLow < current.pricLmtLow) ? prev : current
	          );
	          
	          // 确保清空不相关字段
	          this.form.markUpPric = 0;
	          this.form.markUpFixed = 0;
	          
	          // 填充加成率
	          this.form.markUpRate = selectedRule.markUpRate;
	          
	          // 计算销售单价
	          this.calculateSalePrice();
	          
	          return true;
	        } else {
	          this.$message.warning('未找到匹配当前成本单价的中药加成率规则');
	          this.form.markUpRate = '';
	          this.form.salePric = '';
	          return false;
	        }
	      } else {
	        this.$message.error('未找到中药相关的药品加成率，请先前往加成率设置中添加');
	        this.form.markUpRate = '';
	        this.form.salePric = '';
	        return false;
	      }
	    } else {
	      this.$message.error(res.message || '获取中药加成率失败');
	      this.form.markUpRate = '';
	      this.form.salePric = '';
	      return false;
	    }
	  } catch (error) {
	    console.error('计算中药加成率出错:', error);
	    this.$message.error('计算中药加成率出错');
	    this.form.markUpRate = '';
	    this.form.salePric = '';
	    return false;
	  }
	},
	// 计算销售单价
	// calculateSalePrice() {
	//   if (!this.form.costPric) return;
	  
	//   const cost = parseFloat(this.form.costPric);
	  
	//   if (this.form.markUpId === 1 && this.form.markUpRate) {
	//     // 比例加成: 成本 * 加成率
	//     const rate = this.form.markUpRate;
	//     this.form.salePric = (cost *  rate).toFixed(2);
	//   } 
	//   else if (this.form.markUpId === 2 && this.form.markUpPric) {
	//     // 固定加成: 成本 + 固定金额
	//     const markup = parseFloat(this.form.markUpPric);
	//     this.form.salePric = (cost + markup).toFixed(2);
	//   }
	//   else if (this.form.markUpId === 3 && this.form.markUpRate) {
	//     // 手工比例加成: 成本 * (1 + 手工比例/100)
	//     const rate = parseFloat(this.form.markUpRate) / 100;
	//     this.form.salePric = (cost * (1 + rate)).toFixed(2);
	//   }
	//   else if (this.form.markUpId === 4) {
	//     // 不加成: 零售价=成本价
	//     this.form.salePric = cost.toFixed(2);
	//   }
	  
	//   this.updateForm();
	// },
	// 在成本单价blur事件中调用计算
	  handleCostPricBlur() {
		if (this.form.markUpId === 1 && this.form.costPric) {
		  this.calculateMarkUpRate();
		}
		this.updateForm();
	  },
	// 获取字符串的首字母
	getFirstLetter(str) {
	  if (!str || typeof str !== 'string') return '';
	  
	  try {
		// 使用正则提取所有汉字（过滤非汉字字符）
		const chineseChars = str.match(/[\u4e00-\u9fa5]/g) || [];
		if (chineseChars.length === 0) return '';

		// 对每个汉字获取拼音首字母
		const initials = chineseChars.map(char => {
		  const pinyinResult = pinyin(char, {
			toneType: 'none',
			type: 'array',
			multiple: false, // 只取第一个读音
		  })[0] || '';
		  return pinyinResult.charAt(0).toUpperCase();
		});

		// 组合成简码（如"中国" → "ZG"）
		return initials.join('');
	  } catch (error) {
		console.error('拼音转换失败:', error);
		return '';
	  }
	},
	// datas
	// 包装单位
	async pacUnt(){
		let res = await getDrugUnt();
		if(res.code===200){ this.unitDoseOptions=res.data.map(v => {return { label: v.name, ...v}}) }else{ this.$message.error(res.message) }
	},
	// 毒麻
	async getDocVtByType(){
		let res = await selectDocVtByType();
		this.poisonousTypeOption = res.data.map(v => {return { label: v.name, ...v}})
	},
	// 给药方式
	async getMedicationFrequency(){
		let res = await getMedicationFrequency();
		if(res.code===200){ this.usedFrquIdOptions=res.data.map(v => {return { label: v.name, ...v}}) }else{ this.$message.error(res.message) };
		console.log(this.usedFrquIdOptions,'this.usedFrquIdOptions');
	},
	// 用药频率
	async getMedicationWay(){
		let res = await getMedicationWay();
		if(res.code===200){ this.medcWayIdOptions=res.data.map(v => {return { label: v.name, ...v}}) }else{ this.$message.error(res.message) }
	},
	// 剂量单位
	async getDosaUnts(){
		let res = await getDosaUnt();
		if(res.code===200){ 
			// 最小单位 && 剂量单位
			this.getDosaUntOptions = this.getDosaUntOptions=res.data.map(v => {return { label: v.name, ...v}}) }else{ this.$message.error(res.message)
		}
	},
	//病案费别
	async getMedcas(){
		this.res = await getMedcas();
		if(this.res.code===200){ 
			this.medicalRecordFeeOption=this.res.data.map(v => {return { label: v.name, ...v}})
		}
	},
	// 药理类别
	async selectOneCateGory(){
		let res = await selectOneCateGory();
		if(res.code===200){ 
			this.drugCategoryOption=res.data
		}
	},
	
  }
}
</script>

<style lang="less" scoped>
/deep/ .el-form-item{
	margin-bottom: 8px;
}
.basic-info {
  padding: 4px;
  /deep/ .el-form-item__label{
	  font-size: 12px;
  }
  /deep/ .el-input__inner{
	  padding: 0 4px;
  }
  /deep/ .el-form-item__content{
	  display: flex;
	  justify-content: space-around;
  }
  /deep/ .el-input--mini .el-input__inner{
  	height: 26px;
  }
}
</style>